package top.goldenyear.porpoise.common.core.util.collection;

import cn.hutool.v7.core.collection.CollUtil;

import java.util.*;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors;

/**
 * Collection 工具类
 *
 * @author Airhead
 */
public class CollUtils extends CollUtil {

  public static boolean containsAny(Object source, Object... targets) {
    return Arrays.asList(targets).contains(source);
  }

  public static boolean isAnyEmpty(Collection<?>... collections) {
    return Arrays.stream(collections).anyMatch(CollUtil::isEmpty);
  }

  public static <T> List<T> filterList(Collection<T> from, Predicate<T> predicate) {
    if (CollUtil.isEmpty(from)) {
      return new ArrayList<>();
    }
    return from.stream().filter(predicate).collect(Collectors.toList());
  }

  public static <T, R> List<T> distinct(Collection<T> from, Function<T, R> keyMapper) {
    if (CollUtil.isEmpty(from)) {
      return new ArrayList<>();
    }
    return distinct(from, keyMapper, (t1, t2) -> t1);
  }

  public static <T, R> List<T> distinct(
      Collection<T> from, Function<T, R> keyMapper, BinaryOperator<T> cover) {
    if (CollUtil.isEmpty(from)) {
      return new ArrayList<>();
    }
    return new ArrayList<>(convertMap(from, keyMapper, Function.identity(), cover).values());
  }

  public static <T, U> List<U> convertList(Collection<T> from, Function<T, U> func) {
    if (CollUtil.isEmpty(from)) {
      return new ArrayList<>();
    }
    return from.stream().map(func).filter(Objects::nonNull).collect(Collectors.toList());
  }

  public static <T, U> List<U> convertList(
      Collection<T> from, Function<T, U> func, Predicate<T> filter) {
    if (CollUtil.isEmpty(from)) {
      return new ArrayList<>();
    }
    return from.stream()
        .filter(filter)
        .map(func)
        .filter(Objects::nonNull)
        .collect(Collectors.toList());
  }

  public static <T, U> Set<U> convertSet(Collection<T> from, Function<T, U> func) {
    if (CollUtil.isEmpty(from)) {
      return new HashSet<>();
    }
    return from.stream().map(func).filter(Objects::nonNull).collect(Collectors.toSet());
  }

  public static <T, U> Set<U> convertSet(
      Collection<T> from, Function<T, U> func, Predicate<T> filter) {
    if (CollUtil.isEmpty(from)) {
      return new HashSet<>();
    }
    return from.stream()
        .filter(filter)
        .map(func)
        .filter(Objects::nonNull)
        .collect(Collectors.toSet());
  }

  public static <T, K> Map<K, T> convertMap(Collection<T> from, Function<T, K> keyFunc) {
    if (CollUtil.isEmpty(from)) {
      return new HashMap<>();
    }
    return convertMap(from, keyFunc, Function.identity());
  }

  public static <T, K> Map<K, T> convertMap(
      Collection<T> from, Function<T, K> keyFunc, Supplier<? extends Map<K, T>> supplier) {
    if (CollUtil.isEmpty(from)) {
      return supplier.get();
    }
    return convertMap(from, keyFunc, Function.identity(), supplier);
  }

  public static <T, K, V> Map<K, V> convertMap(
      Collection<T> from, Function<T, K> keyFunc, Function<T, V> valueFunc) {
    if (CollUtil.isEmpty(from)) {
      return new HashMap<>();
    }
    return convertMap(from, keyFunc, valueFunc, (v1, v2) -> v1);
  }

  public static <T, K, V> Map<K, V> convertMap(
      Collection<T> from,
      Function<T, K> keyFunc,
      Function<T, V> valueFunc,
      BinaryOperator<V> mergeFunction) {
    if (CollUtil.isEmpty(from)) {
      return new HashMap<>();
    }
    return convertMap(from, keyFunc, valueFunc, mergeFunction, HashMap::new);
  }

  public static <T, K, V> Map<K, V> convertMap(
      Collection<T> from,
      Function<T, K> keyFunc,
      Function<T, V> valueFunc,
      Supplier<? extends Map<K, V>> supplier) {
    if (CollUtil.isEmpty(from)) {
      return supplier.get();
    }
    return convertMap(from, keyFunc, valueFunc, (v1, v2) -> v1, supplier);
  }

  public static <T, K, V> Map<K, V> convertMap(
      Collection<T> from,
      Function<T, K> keyFunc,
      Function<T, V> valueFunc,
      BinaryOperator<V> mergeFunction,
      Supplier<? extends Map<K, V>> supplier) {
    if (CollUtil.isEmpty(from)) {
      return new HashMap<>();
    }
    return from.stream().collect(Collectors.toMap(keyFunc, valueFunc, mergeFunction, supplier));
  }

  public static <T, K> Map<K, List<T>> convertMultiMap(Collection<T> from, Function<T, K> keyFunc) {
    if (CollUtil.isEmpty(from)) {
      return new HashMap<>();
    }
    return from.stream()
        .collect(Collectors.groupingBy(keyFunc, Collectors.mapping(t -> t, Collectors.toList())));
  }

  public static <T, K, V> Map<K, List<V>> convertMultiMap(
      Collection<T> from, Function<T, K> keyFunc, Function<T, V> valueFunc) {
    if (CollUtil.isEmpty(from)) {
      return new HashMap<>();
    }
    return from.stream()
        .collect(
            Collectors.groupingBy(keyFunc, Collectors.mapping(valueFunc, Collectors.toList())));
  }

  // 暂时没想好名字，先以 2 结尾噶
  public static <T, K, V> Map<K, Set<V>> convertMultiMap2(
      Collection<T> from, Function<T, K> keyFunc, Function<T, V> valueFunc) {
    if (CollUtil.isEmpty(from)) {
      return new HashMap<>();
    }
    return from.stream()
        .collect(Collectors.groupingBy(keyFunc, Collectors.mapping(valueFunc, Collectors.toSet())));
  }

  public static <T> T getFirst(List<T> from) {
    return !CollUtil.isEmpty(from) ? from.get(0) : null;
  }

  public static <T> T findFirst(List<T> from, Predicate<T> predicate) {
    if (CollUtil.isEmpty(from)) {
      return null;
    }
    return from.stream().filter(predicate).findFirst().orElse(null);
  }

  public static <T, V extends Comparable<? super V>> V getMaxValue(
      List<T> from, Function<T, V> valueFunc) {
    if (CollUtil.isEmpty(from)) {
      return null;
    }
    assert from.size() > 0; // 断言，避免告警
    T t = from.stream().max(Comparator.comparing(valueFunc)).get();
    return valueFunc.apply(t);
  }

  public static <T, V extends Comparable<? super V>> V getMinValue(
      List<T> from, Function<T, V> valueFunc) {
    if (CollUtil.isEmpty(from)) {
      return null;
    }
    assert from.size() > 0; // 断言，避免告警
    T t = from.stream().min(Comparator.comparing(valueFunc)).get();
    return valueFunc.apply(t);
  }

  public static <T, V extends Comparable<? super V>> V getSumValue(
      List<T> from, Function<T, V> valueFunc, BinaryOperator<V> accumulator) {
    if (CollUtil.isEmpty(from)) {
      return null;
    }
    assert from.size() > 0; // 断言，避免告警
    return from.stream().map(valueFunc).reduce(accumulator).get();
  }

  public static <T> void addIfNotNull(Collection<T> coll, T item) {
    if (item == null) {
      return;
    }
    coll.add(item);
  }

  public static <T> Collection<T> singleton(T deptId) {
    return deptId == null ? Collections.emptyList() : Collections.singleton(deptId);
  }
}
